#include "ringbuffer_test.h"
#include "uart.h"
#include "mem_utils.h"

//// 测试用的缓冲区大小
//#define BUFFER_SIZE 64

//// 全局测试缓冲区
//static uint8_t test_buffer[BUFFER_SIZE];
//static struct rt_ringbuffer rb;

//// 辅助函数：打印数字
//static void print_num(uint32_t num)
//{
//    if(num == 0)
//    {
//        my_putchar('0');
//        return;
//    }
//    
//    char buffer[12];
//    int i = 0;
//    while(num > 0)
//    {
//        buffer[i++] = '0' + (num % 10);
//        num /= 10;
//    }
//    
//    for(int j = i - 1; j >= 0; j--)
//    {
//        my_putchar(buffer[j]);
//    }
//}

//// 辅助函数：打印测试结果
//static void print_result(const char* test_name, int passed, uint32_t count)
//{
//    my_putstr("\r\n=== ");
//    my_putstr(test_name);
//    my_putstr(" (");
//    print_num(count);
//    my_putstr(" ops) ");
//    my_putstr(passed ? "PASSED ===" : "FAILED ===");
//    my_putstr("\r\n");
//}

//// 辅助函数：打印状态
//static void print_status(const char* op)
//{
//    my_putstr("\r\n[");
//    my_putstr(op);
//    my_putstr("] Data: ");
//    print_num(rt_ringbuffer_data_len(&rb));
//    my_putstr("/");
//    print_num(rt_ringbuffer_space_len(&rb));
//    my_putstr(" (R:");
//    print_num(rb.read_index);
//    my_putstr(" W:");
//    print_num(rb.write_index);
//    my_putstr(")\r\n");
//}

//// 大批量数据测试
//static void massive_data_test(void)
//{
//    my_putstr("\r\n========== MASSIVE DATA TEST ==========\r\n");
//    
//    rt_ringbuffer_init(&rb, test_buffer, BUFFER_SIZE);
//    
//    uint32_t total_written = 0;
//    uint32_t total_read = 0;
//    uint32_t cycles = 0;
//    uint32_t errors = 0;
//    
//    // 连续操作1000次
//    for(int i = 0; i < 1000; i++)
//    {
//        // 随机写入1-20字节
//        uint8_t data[20];
//        for(int j = 0; j < 20; j++)
//            data[j] = (i * 7 + j) & 0xFF;
//        
//        uint32_t write_size = (i % 20) + 1;
//        uint32_t written = rt_ringbuffer_put(&rb, data, write_size);
//        total_written += written;
//        
//        // 随机读取
//        if(i % 3 == 0)
//        {
//            uint8_t read_data[20];
//            uint32_t read_size = (i % 15) + 1;
//            uint32_t read_len = rt_ringbuffer_get(&rb, read_data, read_size);
//            total_read += read_len;
//        }
//        
//        // 检查状态一致性
//        uint32_t data_len = rt_ringbuffer_data_len(&rb);
//        uint32_t space_len = rt_ringbuffer_space_len(&rb);
//        if(data_len + space_len != BUFFER_SIZE)
//            errors++;
//        
//        cycles++;
//    }
//    
//    print_result("Massive Data", (errors == 0), cycles);
//    my_putstr("Written: ");
//    print_num(total_written);
//    my_putstr(", Read: ");
//    print_num(total_read);
//    my_putstr(", Errors: ");
//    print_num(errors);
//    my_putstr("\r\n");
//}

//// 快速填满清空测试
//static void rapid_fill_empty_test(void)
//{
//    my_putstr("\r\n========== RAPID FILL/EMPTY TEST ==========\r\n");
//    
//    rt_ringbuffer_reset(&rb);
//    
//    uint32_t cycles = 0;
//    uint32_t errors = 0;
//    uint8_t test_byte = 0;
//    
//    // 快速填满清空500次
//    for(int i = 0; i < 500; i++)
//    {
//        // 快速填满
//        while(rt_ringbuffer_putchar(&rb, test_byte++) == 1);
//        
//        // 验证已满
//        if(rt_ringbuffer_data_len(&rb) != BUFFER_SIZE)
//            errors++;
//        
//        // 快速清空
//        uint8_t read_byte;
//        while(rt_ringbuffer_getchar(&rb, &read_byte) == 1);
//        
//        // 验证已空
//        if(rt_ringbuffer_data_len(&rb) != 0)
//            errors++;
//        
//        cycles++;
//    }
//    
//    print_result("Rapid Fill/Empty", (errors == 0), cycles);
//    my_putstr("Errors: ");
//    print_num(errors);
//    my_putstr("\r\n");
//}

//// 连续操作测试
//static void continuous_operation_test(void)
//{
//    my_putstr("\r\n========== CONTINUOUS OPERATION TEST ==========\r\n");
//    
//    rt_ringbuffer_reset(&rb);
//    
//    uint32_t operations = 0;
//    uint32_t errors = 0;
//    uint8_t test_data[10];
//    
//    // 连续操作2000次
//    for(int i = 0; i < 2000; i++)
//    {
//        int op = i % 6;
//        
//        switch(op)
//        {
//            case 0: // 单字节写入
//                if(rt_ringbuffer_putchar(&rb, i & 0xFF) == 0)
//                {
//                    if(rt_ringbuffer_space_len(&rb) > 0)
//                        errors++;
//                }
//                break;
//                
//            case 1: // 单字节读取
//                {
//                    uint8_t ch;
//                    if(rt_ringbuffer_getchar(&rb, &ch) == 0)
//                    {
//                        if(rt_ringbuffer_data_len(&rb) > 0)
//                            errors++;
//                    }
//                }
//                break;
//                
//            case 2: // 多字节写入
//                for(int j = 0; j < 10; j++)
//                    test_data[j] = (i + j) & 0xFF;
//                if(rt_ringbuffer_put(&rb, test_data, 10) == 0)
//                {
//                    if(rt_ringbuffer_space_len(&rb) >= 10)
//                        errors++;
//                }
//                break;
//                
//            case 3: // 多字节读取
//                {
//                    uint8_t read_data[10];
//                    if(rt_ringbuffer_get(&rb, read_data, 10) == 0)
//                    {
//                        if(rt_ringbuffer_data_len(&rb) >= 10)
//                            errors++;
//                    }
//                }
//                break;
//                
//            case 4: // Peek操作
//                {
//                    uint8_t *peek_ptr;
//                    uint32_t peek_len = rt_ringbuffer_peek(&rb, &peek_ptr);
//                    if(peek_len > 0 && peek_ptr == NULL)
//                        errors++;
//                }
//                break;
//                
//            case 5: // 状态检查
//                {
//                    uint32_t data_len = rt_ringbuffer_data_len(&rb);
//                    uint32_t space_len = rt_ringbuffer_space_len(&rb);
//                    if(data_len + space_len != BUFFER_SIZE)
//                        errors++;
//                }
//                break;
//        }
//        
//        operations++;
//        
//        // 每500次操作打印状态
//        if(i % 500 == 0)
//        {
//            print_status("Continuous");
//        }
//    }
//    
//    print_result("Continuous Operations", (errors == 0), operations);
//    my_putstr("Errors: ");
//    print_num(errors);
//    my_putstr("\r\n");
//}

//// 边界测试
//static void boundary_test(void)
//{
//    my_putstr("\r\n========== BOUNDARY TEST ==========\r\n");
//    
//    rt_ringbuffer_reset(&rb);
//    
//    uint32_t tests = 0;
//    uint32_t errors = 0;
//    
//    // 测试1：填满缓冲区
//    uint8_t fill_data[BUFFER_SIZE];
//    for(int i = 0; i < BUFFER_SIZE; i++)
//        fill_data[i] = i & 0xFF;
//    
//    uint32_t written = rt_ringbuffer_put(&rb, fill_data, BUFFER_SIZE);
//    if(written != BUFFER_SIZE)
//        errors++;
//    tests++;
//    
//    // 测试2：尝试溢出
//    uint8_t overflow_data[10];
//    for(int i = 0; i < 10; i++)
//        overflow_data[i] = 0xFF;
//    
//    written = rt_ringbuffer_put(&rb, overflow_data, 10);
//    if(written != 0)  // 应该被拒绝
//        errors++;
//    tests++;
//    
//    // 测试3：Force模式
//    written = rt_ringbuffer_put_force(&rb, overflow_data, 10);
//    if(written != 10)
//        errors++;
//    tests++;
//    
//    // 测试4：从空缓冲区读取
//    rt_ringbuffer_reset(&rb);
//    uint8_t read_data[10];
//    uint32_t read_len = rt_ringbuffer_get(&rb, read_data, 10);
//    if(read_len != 0)
//        errors++;
//    tests++;
//    
//    // 测试5：环绕测试
//    rt_ringbuffer_reset(&rb);
//    
//    // 写入到接近末尾
//    uint8_t near_end[BUFFER_SIZE - 5];
//    for(int i = 0; i < BUFFER_SIZE - 5; i++)
//        near_end[i] = i & 0xFF;
//    
//    rt_ringbuffer_put(&rb, near_end, BUFFER_SIZE - 5);
//    
//    // 读取一半
//    rt_ringbuffer_get(&rb, read_data, (BUFFER_SIZE - 5) / 2);
//    
//    // 写入跨越边界的数据
//    uint8_t wrap_data[10];
//    for(int i = 0; i < 10; i++)
//        wrap_data[i] = (i + 100) & 0xFF;
//    
//    written = rt_ringbuffer_put(&rb, wrap_data, 10);
//    if(written != 10)
//        errors++;
//    tests++;
//    
//    print_result("Boundary Tests", (errors == 0), tests);
//    my_putstr("Errors: ");
//    print_num(errors);
//    my_putstr("\r\n");
//}

//// 性能测试
//static void performance_test(void)
//{
//    my_putstr("\r\n========== PERFORMANCE TEST ==========\r\n");
//    
//    rt_ringbuffer_reset(&rb);
//    
//    uint32_t operations = 0;
//    uint8_t test_data[20];
//    
//    // 准备测试数据
//    for(int i = 0; i < 20; i++)
//        test_data[i] = i & 0xFF;
//    
//    // 性能测试：混合操作
//    for(int i = 0; i < 1000; i++)
//    {
//        // 写入
//        rt_ringbuffer_put(&rb, test_data, 5);
//        operations++;
//        
//        // 读取
//        uint8_t read_data[20];
//        rt_ringbuffer_get(&rb, read_data, 3);
//        operations++;
//        
//        // 单字节操作
//        rt_ringbuffer_putchar(&rb, i & 0xFF);
//        operations++;
//        
//        uint8_t ch;
//        rt_ringbuffer_getchar(&rb, &ch);
//        operations++;
//    }
//    
//    print_result("Performance", 1, operations);
//    my_putstr("Total operations: ");
//    print_num(operations);
//    my_putstr("\r\n");
//}

//// 运行所有暴力测试
//void run_ringbuffer_stress_test(void)
//{

//		my_putstr("\r\n");
//		my_putstr("STM32F103 RingBuffer Stress Test Starting...\r\n");
//		my_putstr("UART initialized at 115200 baud\r\n");
//	
//    my_putstr("\r\n");
//    my_putstr("========================================\r\n");
//    my_putstr("    RINGBUFFER STRESS TEST SUITE\r\n");
//    my_putstr("========================================\r\n");
//    
//    massive_data_test();
//    rapid_fill_empty_test();
//    continuous_operation_test();
//    boundary_test();
//    performance_test();
//    
//    my_putstr("\r\n========================================\r\n");
//    my_putstr("    ALL STRESS TESTS COMPLETED\r\n");
//    my_putstr("========================================\r\n");
//	
//		my_putstr("\r\nAll tests completed. Entering main loop...\r\n");

//}
